﻿using FlyingCircusWebIS.Controllers.Utilidades;
using FlyingCircusWebIS.Filtros;
using FlyingCircusWebIS.Models;
using FlyingCircusWebIS.ViewModels.AeroportoVM;
using System;
using System.Collections.Generic;
using System.Data.OleDb;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using PagedList;

namespace FlyingCircusWebIS.Controllers
{

    [AutenticacaoFilter("A")]
    public class AeroportoController : Controller
    {
        
        private IAeroportoService aeroportoService;
        private ICidadeService cidadeService;

        public AeroportoController()
        {
            aeroportoService = new AeroportoService();
            cidadeService = new CidadeService();
        }


        public ActionResult Index(int pagina = 1, string nome = "", string uf = "")
        {
            AeroportoIndexVM vm = ConstruirIndexVM(pagina, nome, uf);
            return View(vm);
        }

        public ActionResult Form(int? id)
        {
            AeroportoFormVM vm;
            if (id.HasValue)
            {
                vm = ConstruirFormVMParaEdicao(id.Value);
                if (vm == null)
                    return new HttpNotFoundResult();
            } 
            else 
            {
                vm = ConstruirFormVMParaNovo();
            }
           
            return View(vm);
        }

        [HttpPost]
        public ActionResult Form(AeroportoFormVM vm)
        {
            if (ModelState.IsValid)
            {
                Aeroporto registro = ConverterFormVM(vm);

                var erros = aeroportoService.ValidarEntidade(registro);
                if (erros.Count == 0)
                {
                    if (vm.Edicao)
                        aeroportoService.Atualizar(registro);
                    else
                        aeroportoService.Adicionar(registro);

                    return RedirectToAction("Index");
                }
                else
                {
                    ModelState.AddModelErrors(erros);
                }
            }


            vm.ItensUF = cidadeService.ListarItensUF();
            vm.ItensCidades = cidadeService.ListarItensCidadesPorUF(vm.UF);
            return View(vm);
        }


        public JsonResult BuscarItensCidades(string uf)
        {
            var itens = cidadeService.ListarItensCidadesPorUF(uf);
            return Json(itens, JsonRequestBehavior.AllowGet);
        }


        public JsonResult Remover(int id)
        {
            JsonActionResultModel jarm = new JsonActionResultModel();

            var erros = aeroportoService.ValidaRemoverPorId(id);
            if (erros.Count == 0)
            {
                aeroportoService.RemoverPorId(id);
                jarm.Erro = false;
                jarm.Mensagem = "Registro removido com sucesso!";
            }
            else
            {
                jarm.Erro = true;
                jarm.Mensagem = "Não é possível remover o registro.\n";
                jarm.AddValidationResultErros(erros);
            }

            return Json(jarm);
        }
       

        // -----------------------------------------------------------------------------------------
        // Métodos auxiliares 
        // -----------------------------------------------------------------------------------------


        private AeroportoIndexVM ConstruirIndexVM(int pagina, string nome, string uf)
        {
            AeroportoIndexVM vm = new AeroportoIndexVM();
            IPagedList<AeroportoCidade> registros = 
                aeroportoService.ListarAeroportoCidadeFiltro(nome, uf).ToPagedList(pagina, 10);
            vm.Registros = registros;
            vm.TotalRegistros = registros.Count;
            vm.ItensUF = cidadeService.ListarItensUF();
            vm.Nome = nome;
            vm.UF = uf;
            return vm;
        }


        private AeroportoFormVM ConstruirFormVMParaNovo()
        {
            AeroportoFormVM vm = new AeroportoFormVM();
            vm.Edicao = false;
            vm.ItensUF = cidadeService.ListarItensUF();
            vm.ItensCidades = cidadeService.ListarItensCidadesParaNovo();
            
            return vm;
        }



   
        private AeroportoFormVM ConstruirFormVMParaEdicao(int id)
        {
            Aeroporto registro = aeroportoService.BuscarPorId(id);
            if (registro != null)
            {
                int idCidade = registro.IdCidade;
                string UF = cidadeService.BuscarUFCidadePorId(idCidade);

                AeroportoFormVM vm = ConverterFormVM(registro);
                vm.UF = UF;
                vm.ItensUF = cidadeService.ListarItensUF();
                vm.ItensCidades = cidadeService.ListarItensCidadesPorUF(UF);
                vm.Edicao = true;
                return vm;
            }

            return null;
        }


        private AeroportoFormVM ConverterFormVM(Aeroporto registro)
        {
            AeroportoFormVM vm = new AeroportoFormVM();
            vm.IdAeroporto = registro.IdAeroporto;
            vm.NomeAeroporto = registro.NomeAeroporto;
            vm.Latitude = registro.Latitude.ToString();
            vm.Longitude = registro.Longitude.ToString();
            vm.IdCidade = registro.IdCidade;

            return vm;
        }



        private Aeroporto ConverterFormVM(AeroportoFormVM vm)
        {
            Aeroporto registro = new Aeroporto();
            registro.IdAeroporto = vm.IdAeroporto;
            registro.NomeAeroporto = vm.NomeAeroporto;
            if (vm.Latitude != null)
                registro.Latitude = Double.Parse(vm.Latitude, System.Globalization.CultureInfo.InvariantCulture);
            if (vm.Longitude != null)
                registro.Longitude = Double.Parse(vm.Longitude, System.Globalization.CultureInfo.InvariantCulture);
            registro.IdCidade = vm.IdCidade;
            
            return registro;
        }

 

    }
}
